package com.woniuxy.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;

//新建队列
@Configuration
public class RabbitmqConfig {

    @Bean
    public Queue simpleQueue(){
        //参数1：队列在rabbitmq中的名字
        //参数2：是否持久化，关闭mq服务后该队列是否存在
        //参数3：是否具有排他属性，是：只能一个消费者消费
        //参数4：是否自动删除，当队列中没有消息了，该队列是否删除
        //参数5：其他参数
        return new Queue("simpleQueue",true,false,false);
    }


    @Bean
    public Queue workQueue(){
        return new Queue("workQueue");
    }

    /**
     * 广播模式
     * 组成：一个生产者，一个交换机，多个队列，多消费者
     * @return
     */
    @Bean
    public Queue fanoutQueueA(){
        return new Queue("fanoutQueueA");
    }
    @Bean
    public Queue fanoutQueueB(){
        return new Queue("fanoutQueueB");
    }

    @Bean
    public FanoutExchange fanoutExchange(){
        //参数1：交换机名字
        //参数2：是否持久化
        //参数3：是否自动删除 当没有队列和交换机绑定时，是否自动删除
        return new FanoutExchange("fanoutExchange");
    }

    //队列和交换机绑定
    @Bean
    public Binding fanoutQueueAToFanoutExchange(){
        //                                将队列   绑定    到交换机
        return BindingBuilder.bind(fanoutQueueA()).to(fanoutExchange());
    }

    @Bean
    public Binding fanoutQueueBToFanoutExchange(){
        //                                将队列   绑定    到交换机
        return BindingBuilder.bind(fanoutQueueB()).to(fanoutExchange());
    }

//    @Bean                                             自动注入
//    public Binding fanoutQueueAToFanoutExchange(Queue fanoutQueueA,FanoutExchange fanoutExchange){
//        //                                将队列   绑定    到交换机
//        return BindingBuilder.bind(fanoutQueueA).to(fanoutExchange);
//    }


    /**
     *
     * 路由模式
     * 组成：和广播模式一样
     * 特点：可以把消息转发给指定的队列
     */
    @Bean
    public Queue directQueueA(){
        return new Queue("directQueueA");
    }

    @Bean
    public Queue directQueueB(){
        return new Queue("directQueueB");
    }

    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("directExchange");
    }

    @Bean
    public Binding directQueueATodirectExchange(){
        return BindingBuilder.bind(directQueueA()).to(directExchange()).with("red");
    }

    @Bean
    public Binding directQueueBTodirectExchange(){
        return BindingBuilder.bind(directQueueB()).to(directExchange()).with("green");
    }


    /**
     * 主题模式
     * 路由可以使用通配符
     */

    @Bean
    public Queue topicQueueA(){
        return new Queue("topicQueueA");
    }

    @Bean
    public Queue topicQueueB(){
        return new Queue("topicQueueB");
    }

    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topicExchange");
    }

    @Bean
    public Binding topicQueueAToTopicExchange(){
        return BindingBuilder.bind(topicQueueA()).to(topicExchange()).with("#.food");
    }

    @Bean
    public Binding topicQueueBToTopicExchange(){
        return BindingBuilder.bind(topicQueueB()).to(topicExchange()).with("user.*");
    }


    /**
     * 延迟队列
     * @return
     */
    @Bean
    public Queue delayQueue(){
        return new Queue("delayQueue");
    }

    /**
     *
     * CustomExchange:自定义交换机（死信交换机）
     * 本质还是学（广播，路由，主题）
     * @return
     */
    @Bean
    public CustomExchange delayExchange(){
        Map map = new HashMap();
        //指定交换机类型
        map.put("x-delayed-type","direct");
        /**
         参数1：交换机名字
         参数2；消息类型（死信消息）
         参数3：是否持久化
         参数4：是否自动参数
         参数5：其他参数（交换机的类型，队列长度）
         */
        return new CustomExchange("delayExchange","x-delayed-message",
                true,false,map);
    }

    @Bean
    public Binding delayQueueToCustomExchange(){
        return BindingBuilder.bind(delayQueue()).to(delayExchange()).with("delay").noargs();

    }
}
